In `@HadesArtemisAdapter/artemis_adapter.go`:
- Around line 93-122: checkAndSendIfReady can run concurrently from StoreLogs
and StoreResults and cause duplicate sends because aa.logs.Load and
aa.results.Load are not atomic with the subsequent deletes; protect the entire
check-and-send-and-delete sequence with mutual exclusion. Add a per-job mutex
map (or a single mutex) on ArtemisAdapter (e.g., a field like jobLocks
map[string]*sync.Mutex or a sync.Mutex lock) and acquire the appropriate lock at
the start of checkAndSendIfReady (or have StoreLogs/StoreResults lock per job
before calling it) so the load, conditional, sendToArtemis(results) and
aa.logs.Delete/aa.results.Delete execute under the same lock, then release the
lock after cleanup to ensure exactly-once delivery for a jobID.
- Around line 125-149: The sendToArtemis function currently logs errors but
continues, leading to nil-pointer dereferences and always returning nil; update
sendToArtemis (in artemis_adapter.go) to check and return errors immediately
after json.Marshal, http.NewRequest, and aa.httpClient.Do (wrap each error with
context, e.g., fmt.Errorf("marshal request: %w", err)), only call defer
resp.Body.Close() after confirming resp != nil, and return the error to callers
instead of nil so checkAndSendIfReady can detect failures; ensure success path
still returns nil.
- Around line 65-68: Replace the hardcoded Artemis constants with configuration
loaded from environment/config to avoid committing secrets and localhost URLs:
remove the literal artemisAuthToken and artemisBaseURL values and read them from
env/config (e.g., ARTEMIS_BASE_URL, ARTEMIS_AUTH_TOKEN) into the adapter's
config struct (same pattern as other files using `env` tags), keep
newResultEndpoint as a constant path if desired but compose full URL from the
configured base, and move requestTimeout into the config (or use a sensible
default) so no secrets or deploy-specific URLs remain in
artemisBaseURL/artemisAuthToken in artemis_adapter.go.
- Around line 78-84: StoreLogs currently assumes logs[1] exists and does
execution_logs := logs[1].Logs which panics if logs has fewer than 2 entries;
update StoreLogs to check slice length and nil/empty elements before accessing
index 1, return a clear error if execution logs are missing (or skip storing and
return nil depending on caller expectations), and rename execution_logs to
executionLogs to follow Go naming conventions; ensure you still call
aa.logs.Store(jobID, executionLogs) and return aa.checkAndSendIfReady(jobID)
only after a successful bounds-checked extraction.

In `@HadesArtemisAdapter/go.mod`:
- Line 36: The project currently pins the indirect dependency
"github.com/quic-go/quic-go v0.54.0" which has HIGH-severity CVEs; update the
dependency to v0.57.0 or later by replacing the version entry for
github.com/quic-go/quic-go in go.mod and then run go get
github.com/quic-go/quic-go@v0.57.0 (or a newer stable release) followed by go
mod tidy to refresh the module graph and vendor files; verify no other
dependency requires the older version and run your test suite to confirm
compatibility.
- Around line 1-3: Update the module declaration in go.mod to match the
repository naming convention by replacing the current module name
`Hades-ArtemisAdapter` with `github.com/ls1intum/hades/artemis-adapter`; ensure
imports across the module (packages referencing this module) are updated to the
new path if needed and keep the existing Go version (go 1.25.3) unchanged.

In `@HadesArtemisAdapter/main.go`:
- Around line 138-148: The POST /test-results handler currently calls
aa.StoreResults(newResults.UUID, newResults) and ignores its returned error, so
failures (including from sendToArtemis) still return 201; update the handler to
capture the error from StoreResults, log it (slog.Error) with context (uuid and
error), and respond with an appropriate HTTP status (e.g., 500) and error
message when non-nil; keep successful behavior unchanged (log debug and return
201 with the payload).
- Around line 100-102: The 500ms shutdown timeout in the context.WithTimeout
call (where shutdownCtx, shutdownCancel are created) is too short and will kill
in-flight requests like sendToArtemis; change the timeout to a more reasonable
value (e.g., 15–30 seconds) by replacing 500*time.Millisecond with a longer
duration (suggest 30*time.Second) or wire a configurable ShutdownTimeout
constant/flag so main.go uses the same 30s policy as HadesLogManager when
calling context.WithTimeout to create shutdownCtx and shutdownCancel.
- Around line 125-135: The handler reading newLogs via c.BindJSON can panic
because it accesses newLogs[0].JobID without checking the slice length and it
ignores the error returned by aa.StoreLogs; update the POST "/logs" handler to
validate that newLogs is non-empty after BindJSON (return a 400/422 with a
logged error if empty), use newLogs[0].JobID only after that check, call
aa.StoreLogs(...) and handle its returned error (log it and return a
500/appropriate status on failure), and ensure the response (c.IndentedJSON) is
only sent after successful storage; refer to the variables/funcs newLogs,
c.BindJSON, aa.StoreLogs, and c.IndentedJSON to locate the change.

In `@HadesLogManager/processor.go`:
- Line 17: The constant APIendpoint in processor.go is hardcoded to
"http://localhost:8082/adapter/logs" which breaks non-local deployments; change
it to be configurable via an environment-driven config (e.g., add a field to
AggregatorConfig such as LogsAPIEndpoint or create a dedicated config struct)
and replace usages of APIendpoint with that config field, initializing the value
from an environment variable (with a sensible default) during program startup.
- Around line 199-233: In SendJobLogs, stop continuing after failures: after
json.Marshal(logs) return the error (with a logged message) if err != nil; after
http.NewRequest("POST", APIendpoint, ...) return the error if err != nil instead
of proceeding to use req; after client.Do(req) check resp and err and if err !=
nil return it (after logging) and only then use resp; move defer
resp.Body.Close() immediately after the nil-check that confirms resp != nil; and
ensure SendJobLogs returns non-nil errors (propagate or wrap them) instead of
always returning nil so callers can handle failures.

In @.env.example:
- Line 28: The environment variable name in .env.example (ARTEMIS_ADAPTER_PORT)
doesn't match the struct tag read by AdapterConfig in
HadesArtemisAdapter/main.go (env:"API_PORT"); update .env.example to rename
ARTEMIS_ADAPTER_PORT=8082 to API_PORT=8082 so AdapterConfig picks it up, or
alternatively change the AdapterConfig struct tag from env:"API_PORT" to
env:"ARTEMIS_ADAPTER_PORT" to keep the current .env.example—choose one
consistent fix and apply it to ensure the env name and AdapterConfig match.

In `@HadesArtemisAdapter/artemis_adapter.go`:
- Around line 78-90: StoreLogs currently logs an Error but proceeds to store an
empty executionLogs and calls checkAndSendIfReady, causing results to be sent
without logs; update StoreLogs to not proceed when execution logs are missing:
inside StoreLogs (function StoreLogs) when len(logs) < 2, either (preferred)
return a descriptive error (e.g., fmt.Errorf("missing execution logs for job
%s", jobID)) and do not call aa.logs.Store or checkAndSendIfReady, keeping or
strengthening the Error log, or if degraded behavior is intentional change the
slog.Error to slog.Warn and return nil as before; ensure the
aa.logs.Store(jobID, ...) and call to checkAndSendIfReady(jobID) only happen in
the successful branch where executionLogs is populated.

In `@HadesArtemisAdapter/main.go`:
- Around line 131-136: The error message in the /logs handler is a copy-paste:
when binding into newLogs (type []buildlogs.Log) the slog.Error call uses
"Failed to bind test results JSON"; update that log to accurately reflect this
handler (e.g., "Failed to bind logs JSON") so the message matches the endpoint
and variable names (jobs.POST("/logs" handler, newLogs, c.BindJSON, slog.Error).
- Around line 34-35: LoadConfig's returned error is being ignored which can
leave AdapterConfig (cfg) zero-valued; change the call to capture and handle the
error from utils.LoadConfig(&cfg) in main: call err := utils.LoadConfig(&cfg)
and if err != nil log the error (including err) and exit (or return) so we don't
continue with empty fields like ArtemisBaseURL or ArtemisAuthToken; reference
symbols: AdapterConfig, utils.LoadConfig, cfg, ArtemisBaseURL, ArtemisAuthToken.

In `@HadesLogManager/processor.go`:
- Around line 202-227: SendJobLogs currently treats any HTTP response as success
because it never checks resp.StatusCode; update SendJobLogs to inspect
resp.StatusCode after client.Do(req) and treat non-2xx codes as errors by
reading resp.Body (to include adapter error details) and returning a formatted
error (e.g., include status code and body). Keep the existing defer
resp.Body.Close(), but add a small read of resp.Body (use ioutil.ReadAll or
io.ReadAll) for the error case and return fmt.Errorf with both resp.StatusCode
and the response body string; only return nil when resp.StatusCode is in the
200–299 range.